home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Languages / MPW Oberon 2.1168 / OInterfaces / ScalerTypes.mod < prev    next >
Encoding:
Text File  |  1995-08-10  |  19.3 KB  |  464 lines  |  [TEXT/MPS ]
  1. (*
  2.      File:        ScalerTypes.mod
  3.  
  4.      Contains:    Apple public font scaler object and constant definitions
  5.  
  6.      Version:    Technology:    Quickdraw GX 1.1
  7.                  Package:    Universal Interfaces 2.1ß1 in “MPW Prerelease” on ETO #17
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs.applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. *)
  19.  
  20. (*$TAGS-*)
  21. (*$CALLING PASCAL*)
  22. MODULE ScalerTypes;
  23.  
  24. IMPORT SYSTEM, Types, GXMath, GXTypes;
  25.  
  26. (* $PUSH*)
  27. (* $ALIGN MAC68K*)
  28. (* $LibExport+*)
  29. (*$SET scalerTypeIncludes TRUE*)
  30.  
  31. CONST
  32.     truetypeFontFormatTag*        = LONG("true");
  33.     type1FontFormatTag*            = LONG("typ1");
  34.     nfntFontFormatTag*            = LONG("nfnt");
  35.  
  36.     scaler_first_error*            = 1;
  37.     scaler_first_warning*        = 1024;
  38.  
  39.     kOFAVersion1Dot0*            = $10000;
  40.     kOFAVersion1Dot1*            = $10100;                        (* added scalerVariationInfo *)
  41.  
  42.     scaler_no_problem*            = 0;                            (* Everything went OK *)
  43.     scaler_null_context*            = scaler_first_error;            (* Client passed a null context pointer *)
  44.     scaler_null_input*            = scaler_first_error + 1;        (* Client passed a null input pointer *)
  45.     scaler_invalid_context*        = scaler_first_error + 2;        (* There was a problem with the context *)
  46.     scaler_invalid_input*        = scaler_first_error + 3;        (* There was a problem with an input *)
  47.     scaler_invalid_font_data*    = scaler_first_error + 4;        (* A portion of the font was corrupt *)
  48.     scaler_new_block_failed*        = scaler_first_error + 5;        (* A call to NewBlock() failed *)
  49.     scaler_get_font_table_failed* = scaler_first_error + 6;        (* The table was present (length > 0) but couldn't be read *)
  50.     scaler_bitmap_alloc_failed*    = scaler_first_error + 7;        (* Call to allocate bitmap permanent block failed *)
  51.     scaler_outline_alloc_failed*    = scaler_first_error + 8;        (* Call to allocate outline permanent block failed *)
  52.     scaler_required_table_missing* = scaler_first_error + 9;        (* A needed font table was not found *)
  53.     scaler_unsupported_outline_format* = scaler_first_error + 10; (* Couldn't create an outline of the desired format *)
  54.     scaler_unsupported_stream_format* = scaler_first_error + 11;    (* ScalerStreamFont() call can't supply any requested format *)
  55.     scaler_unsupported_font_format* = scaler_first_error + 12;    (* No scaler supports the font format *)
  56.     scaler_hinting_error*        = scaler_first_error + 13;        (* An error occurred during hinting *)
  57.     scaler_scan_error*            = scaler_first_error + 14;        (* An error occurred in scan conversion *)
  58.     scaler_internal_error*        = scaler_first_error + 15;        (* Scaler has a bug *)
  59.     scaler_invalid_matrix*        = scaler_first_error + 16;        (* The transform matrix was unusable *)
  60.     scaler_fixed_overflow*        = scaler_first_error + 17;        (* An overflow ocurred during matrix operations *)
  61.     scaler_API_version_mismatch*    = scaler_first_error + 18;        (* Scaler requires a newer/older version of the scaler API *)
  62.     scaler_streaming_aborted*    = scaler_first_error + 19;        (* StreamFunction callback indicated that streaming should cease *)
  63.     scaler_last_error*            = scaler_streaming_aborted;
  64.     scaler_no_output*            = scaler_first_warning;            (* Couldn't fulfill any glyph request. *)
  65.     scaler_fake_metrics*            = scaler_first_warning;            (* Returned metrics aren't based on information in the font *)
  66.     scaler_fake_linespacing*        = scaler_first_warning;            (* Linespacing metrics not based on information in the font *)
  67.     scaler_glyph_substitution*    = scaler_first_warning;            (* Requested glyph out of range, a substitute was used *)
  68.     scaler_last_warning*            = scaler_glyph_substitution;
  69.  
  70.     
  71. TYPE
  72.     scalerError* = LONGINT;
  73.  
  74. (* ScalerOpen output type *)
  75.     scalerInfo* = RECORD
  76.         format*:                    GXTypes.gxFontFormatTag;                        (* Font format supported by this scaler *)
  77.         scalerVersion*:            Types.Fixed;                                    (* Version number of the scaler *)
  78.         APIVersion*:                Types.Fixed;                                    (* Version of API implemented (compare with version in scalerContext) *)
  79.     END;
  80.  
  81. (* ScalerNewFont output type *)
  82.  
  83. CONST
  84.     requiresLayoutFont*            = 1;
  85.     hasNormalLayoutFont*            = 2;
  86.     canReorderFont*                = 4;
  87.     canRearrangeFont*            = 8;
  88.     hasOutlinesFont*                = 16;
  89.  
  90.     
  91. TYPE
  92.     scalerFontFlag* = LONGINT;
  93.  
  94.     scalerFontInfo* = RECORD
  95.         unitsPerEm*:                LONGINT;
  96.         flags*:                    scalerFontFlag;
  97.         numGlyphs*:                LONGINT;
  98.     END;
  99.  
  100. (* ScalerNewTransform input types *)
  101. (* ScalerNewVariation1Dot1 output type *)
  102.     scalerFixedRectangle* = RECORD
  103.         left*:                    Types.Fixed;
  104.         top*:                    Types.Fixed;
  105.         right*:                    Types.Fixed;
  106.         bottom*:                    Types.Fixed;
  107.     END;
  108.  
  109.     scalerVariationInfo* = RECORD
  110.         bounds*:                    scalerFixedRectangle;
  111.     END;
  112.  
  113. (* ScalerNewTransform input types *)
  114.  
  115. CONST
  116.     applyHintsTransform*            = 1;                            (* Execute hinting instructions (grid fit) *)
  117.     exactBitmapTransform*        = 2;                            (* Use embedded gxBitmap iff exact size *)
  118.     useThresholdTransform*        = 4;                            (* Use scaled gxBitmap (if any) if below outline threshold *)
  119.     verticalTransform*            = 8;                            (* Glyphs will be in vertical orientation *)
  120.     deviceMetricsTransform*        = 16;                            (* All metrics should be device (vs. fractional) *)
  121.     allScalerTransformFlags*        = applyHintsTransform + exactBitmapTransform + useThresholdTransform + verticalTransform + deviceMetricsTransform;
  122.  
  123.     
  124. TYPE
  125.     scalerTransformFlag* = LONGINT;
  126.  
  127.     scalerTransform* = RECORD
  128.         flags*:                    scalerTransformFlag;                    (* Hint, embedded gxBitmap control, etc. *)
  129.         pointSize*:                Types.Fixed;                                    (* The desired pointsize *)
  130.         fontMatrix*:                POINTER TO GXMath.gxMapping;                                (* The 3x3 matrix to apply to glyphs *)
  131.         resolution*:                GXMath.gxPoint;                                (* 2D device resolution *)
  132.         spotSize*:                GXMath.gxPoint;                                (* 2D pixel size *)
  133.     END;
  134.  
  135. (* ScalerNewTransform output type *)
  136.     scalerTransformInfo* = RECORD
  137.         before*:                    GXMath.gxPoint;                                (* Spacing of the line before *)
  138.         after*:                    GXMath.gxPoint;                                (* Spacing of the line after *)
  139.         caretAngle*:                GXMath.gxPoint;                                (* Rise (y) and run (x) of the insertion caret *)
  140.         caretOffset*:            GXMath.gxPoint;                                (* Adjustment to caret for variants like italic *)
  141.     END;
  142.  
  143. (* ScalerNewGlyph input types *)
  144.  
  145. CONST
  146.     noImageGlyph*                = 1;                            (* Don't return the bitmap image for this glyph *)
  147.  
  148.     
  149. TYPE
  150.     scalerGlyphFlag* = LONGINT;
  151.  
  152. (* QuickDraw GX outline *)
  153.  
  154. CONST
  155.     pathOutlineFormat*            = LONG("path");
  156.  
  157.     
  158. TYPE
  159.     scalerOutlineFormat* = LONGINT;
  160.  
  161.     scalerGlyph* = RECORD
  162.         glyphIndex*:                LONGINT;                                (* Index of the glyph to be considered *)
  163.         bandingTop*:                LONGINT;                                (* Banding controls (scanline numbers) top=bottom=0 means no banding *)
  164.         bandingBottom*:            LONGINT;
  165.         format*:                    scalerOutlineFormat;                    (* Format of outline to return, ignored if no outline desired *)
  166.         flags*:                    scalerGlyphFlag;                        (* Control generation of image representation *)
  167.     END;
  168.  
  169. (* ScalerNewGlyph output types *)
  170.     scalerMetrics* = RECORD
  171.         advance*:                GXMath.gxPoint;
  172.         sideBearing*:            GXMath.gxPoint;
  173.         otherSideBearing*:        GXMath.gxPoint;
  174.     END;
  175.  
  176.     scalerRectangle* = RECORD
  177.         xMin*:                    LONGINT;
  178.         yMin*:                    LONGINT;
  179.         xMax*:                    LONGINT;
  180.         yMax*:                    LONGINT;
  181.     END;
  182.  
  183. (* ScalerKernGlyphs input/output types *)
  184.  
  185. CONST
  186.     lineStartKerning*            = 1;                            (* Array of glyphs starts a line *)
  187.     lineEndKerning*                = 2;                            (* Array of glyphs ends a line *)
  188.     noCrossKerning*                = 4;                            (* Prohibit cross kerning *)
  189.     allScalerKerningFlags*        = lineStartKerning + lineEndKerning + noCrossKerning;
  190.  
  191.     
  192. TYPE
  193.     scalerKerningFlag* = LONGINT;
  194.  
  195.  
  196. CONST
  197.     noStakeKerningNote*            = 1;                            (* Indicates a glyph was involver in a kerning pair/group *)
  198.     crossStreamResetKerningNote*    = 2;                            (* Indicates a return-to-baseline in cross-stream kerning *)
  199.  
  200.     
  201. TYPE
  202.     scalerKerningNote* = INTEGER;
  203.  
  204.  
  205. CONST
  206.     noKerningAppliedOutput*        = $0001;                        (* All kerning values were zero, kerning call had no effect *)
  207.  
  208. (* These are bit-fields *)
  209.     
  210. TYPE
  211.     scalerKerningOutput* = LONGINT;
  212.  
  213.     scalerKerning* = RECORD
  214.         numGlyphs*:                LONGINT;                                (* Number of glyphs in the glyphs array *)
  215.         scaleFactor*:            Types.Fract;                                    (* Amount of kerning to apply (0 == none, fract1 == all) *)
  216.         flags*:                    scalerKerningFlag;                        (* Various control flags *)
  217.         glyphs*:                    SYSTEM.PTR (*ΔΔ POINTER TO INTEGER*);                                (* Pointer to the array of glyphs to be kerned *)
  218.         info*:                    scalerKerningOutput;                    (* Qualitative results of kerning *)
  219.     END;
  220.  
  221. (* ScalerStream input/output types *)
  222.  
  223. CONST
  224.     cexec68K*                    = $0001;
  225.     truetypeStreamType*            = $0001;
  226.     type1StreamType*                = $0002;
  227.     type3StreamType*                = $0004;
  228.     type42StreamType*            = $0008;
  229.     type42GXStreamType*            = $0010;
  230.     portableStreamType*            = $0020;
  231.     flattenedStreamType*            = $0040;
  232.     evenOddModifierStreamType*    = $8000;
  233.  
  234. (* Possible streamed font formats *)
  235.     
  236. TYPE
  237.     scalerStreamTypeFlag* = LONGINT;
  238.  
  239.  
  240. CONST
  241.     downloadStreamAction*        = 0;                            (* Transmit the (possibly sparse) font data *)
  242.     asciiDownloadStreamAction*    = 1;                            (* Transmit font data to a 7-bit ASCII destination *)
  243.     fontSizeQueryStreamAction*    = 2;                            (* Estimate in-printer memory used if the font were downloaded *)
  244.     encodingOnlyStreamAction*    = 3;                            (* Transmit only the encoding for the font *)
  245.     prerequisiteQueryStreamAction* = 4;                            (* Return a list of prerequisite items needed for the font *)
  246.     prerequisiteItemStreamAction* = 5;                            (* Transmit a specified prerequisite item *)
  247.     variationQueryStreamAction*    = 6;                            (* Return information regarding support for variation streaming *)
  248.     variationPSOperatorStreamAction* = 7;                        (* Transmit Postscript code necessary to effect variation of a font *)
  249.  
  250.     
  251. TYPE
  252.     scalerStreamAction* = LONGINT;
  253.  
  254.  
  255. CONST
  256.     selectAllVariations*            = -1;                            (* Special variationCount value meaning include all variation data *)
  257.  
  258.  
  259. TYPE
  260.     scalerPrerequisiteItem* = RECORD
  261.         enumeration*:            LONGINT;                                (* Shorthand tag identifying the item *)
  262.         size*:                    LONGINT;                                (* Worst case vm in printer item requires *)
  263.         name*:                    ARRAY 1 (*ΔΔ[0..0]ΔΔ*) OF Types.SInt8; (* unsigned char *) (* Name to be used by the client when emitting the item (Pascal string) *)
  264.     END;
  265.  
  266.     scalerStream* = RECORD
  267.         streamRefCon*:            Types.Ptr;                                    (* <-    private reference for client *)
  268.         targetVersion*:            POINTER TO ARRAY OF CHAR;                                    (* <-    e.g. Postscript printer name (C string) *)
  269.         types*:                    scalerStreamTypeFlag;                    (* <->    Data stream formats desired/supplied *)
  270.         action*:                    scalerStreamAction;                        (* <-     What action to take *)
  271.         memorySize*:                LONGINT;                                (* ->    Worst case memory use (vm) in printer or as sfnt *)
  272.         variationCount*:            LONGINT;                                (* <-    The number of variations, or selectAllVariations *)
  273.         variations*:                POINTER TO GXTypes.gxFontVariation;                        (* <-    A pointer to an array of the variations *)
  274.         (*ΔΔ CASE INTEGER OF
  275.         0: ( *)
  276.     END;
  277.     scalerStream0* = RECORD(scalerStream)
  278.             encoding*:                    SYSTEM.PTR (*ΔΔ POINTER TO INTEGER*);                            (* <-    Intention is * unsigned short[256] *)
  279.             glyphBits*:                    SYSTEM.PTR (*ΔΔ POINTER TO LONGINT*);                            (* <->    Bitvector*: a bit for each glyph, 1* = desired/supplied *)
  280.             name*:                        POINTER TO ARRAY OF CHAR;                                (* <->    The printer font name to use/used (C string) *)
  281.            (*ΔΔ );
  282.         1: ( *)
  283.     END;
  284.     scalerStream1* = RECORD(scalerStream)
  285.             size*:                        LONGINT;                            (* ->     Memory.Size of the prereq. list in bytes (0 indicates no prerequisites)*)
  286.             list*:                        Types.Ptr;                                (* <-    Pointer to client block to hold list (nil* = list size query only) *)
  287.            (*ΔΔ );
  288.         2: (  *)
  289.     END;
  290.     scalerStream2* = RECORD(scalerStream)
  291.             prerequisiteItem*:            LONGINT;                            (* <-     Enumeration value for the prerequisite item to be streamed.*)
  292.            (*ΔΔ );
  293.         3: ( *)
  294.     END;
  295.     scalerStream3* = RECORD(scalerStream)
  296.             variationQueryResult*:        LONGINT;                            (* ->    Output from the variationQueryStreamAction *)
  297.            (*ΔΔ );*)
  298.     END;
  299.  
  300.     scalerStreamData* = RECORD
  301.         hexFlag*:                LONGINT;                                (* Indicates that the data is to be interpreted as hex, versus binary *)
  302.         byteCount*:                LONGINT;                                (* Number of bytes in the data being streamed *)
  303.         data*:                    Types.Ptr;                                    (* Pointer to the data being streamed *)
  304.     END;
  305.  
  306.  
  307. CONST
  308.     scalerScratchBlock*            = -1;                            (* Scaler alloced/freed temporary memory *)
  309.     scalerOpenBlock*                = 0;                            (* Five permanent input/state block types *)
  310.     scalerFontBlock*                = 1;
  311.     scalerVariationBlock*        = 2;
  312.     scalerTransformBlock*        = 3;
  313.     scalerGlyphBlock*            = 4;
  314.     scalerBlockCount*            = 5;                            (* Number of permanent block types *)
  315.     scalerOutlineBlock*            = scalerBlockCount;                (* Two output block types *)
  316.     scalerBitmapBlock*            = scalerBlockCount + 1;
  317.  
  318.     
  319. TYPE
  320.     scalerBlockType* = LONGINT;
  321.  
  322. (* special tag used only by scalers to access an sfnt's directory *)
  323.  
  324. CONST
  325.     sfntDirectoryTag*            = LONG("dir ");
  326.  
  327. (* Type definitions for function pointers used with the scalerContext structure *)
  328. TYPE
  329.     GetFontTableProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (VAR context: scalerContext; tableTag: gxFontTableTag; offset: LONGINT; length: LONGINT; data: (*ΔΔUNIVΔΔ*) Types.Ptr): LONGINT;
  330.     ReleaseFontTableProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (VAR context: scalerContext; fontData: (*ΔΔUNIVΔΔ*) Types.Ptr);
  331.     NewBlockProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (VAR context: scalerContext; size: LONGINT; theType: scalerBlockType; oldBlock: (*ΔΔUNIVΔΔ*) Types.Ptr): Types.Ptr;
  332.     DisposeBlockProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (VAR context: scalerContext; scratchData: (*ΔΔUNIVΔΔ*) Types.Ptr; theType: scalerBlockType);
  333.     StreamFunctionProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (VAR context: scalerContext; VAR streamInfo: scalerStream; (*CONST*)VAR dataInfo: scalerStreamData): LONGINT;
  334.     ScanLineFunctionProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (VAR context: scalerContext; (*CONST*)VAR scanLine: scalerBitmap);
  335.     PostErrorFunctionProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (VAR context: scalerContext; theProblem: scalerError);
  336.     ScalerFunctionProcPtr* = (*ΔΔ Types.ProcPtr;*) PROCEDURE (VAR context: scalerContext; data: (*ΔΔUNIVΔΔ*) Types.Ptr);
  337.     GetFontTableUPP* = Types.UniversalProcPtr;
  338.     ReleaseFontTableUPP* = Types.UniversalProcPtr;
  339.     NewBlockUPP* = Types.UniversalProcPtr;
  340.     DisposeBlockUPP* = Types.UniversalProcPtr;
  341.     StreamFunctionUPP* = Types.UniversalProcPtr;
  342.     ScanLineFunctionUPP* = Types.UniversalProcPtr;
  343.     PostErrorFunctionUPP* = Types.UniversalProcPtr;
  344.     ScalerFunctionUPP* = Types.UniversalProcPtr;
  345.  
  346.     scalerBitmap* = RECORD
  347.         image*:                    SYSTEM.PTR (*ΔΔ POINTER TO CHAR*);                                    (* Pointer to pixels *)
  348.         topLeft*:                GXMath.gxPoint;                                (* Bitmap positioning relative to client's origin *)
  349.         bounds*:                    scalerRectangle;                        (* Bounding box of bitmap *)
  350.         rowBytes*:                LONGINT;                                (* Width in bytes *)
  351.     END;
  352.  
  353. (* scalerContext*: the vehicle with which the caller and scaler communicate *)
  354.     scalerContext* = RECORD
  355.         version*:                Types.Fixed;                                    (* Version of the scaler API implemented by the caller *)
  356.         theFont*:                Types.Ptr;                                    (* Caller's private reference to the font being processed *)
  357.         format*:                    GXTypes.gxFontFormatTag;                        (* Format of the sfnt font data, corresponds to the scaler *)
  358.         GetFontTable*:            GetFontTableUPP;                        (* Callback for accessing sfnt tables or portions thereof *)
  359.         ReleaseFontTable*:        ReleaseFontTableUPP;                    (* Callback for releasing sfnt tables *)
  360.         NewBlock*:                NewBlockUPP;                            (* Callback for allocating and/or growing permanent and scratch blocks *)
  361.         DisposeBlock*:            DisposeBlockUPP;                        (* Callback for freeing permanent and scratch blocks *)
  362.         StreamFunction*:            StreamFunctionUPP;                        (* Callback for transmitting blocks of data during streaming *)
  363.         ScanLineFunction*:        ScanLineFunctionUPP;                    (* Callback for emitting individual bitmap scanlines during scan conversion *)
  364.         PostErrorFunction*:        PostErrorFunctionUPP;                    (* Callback for posting errors and warnings *)
  365.         scalerBlocks*:            ARRAY (*ΔΔ[0..*)scalerBlockCount(*ΔΔ -1]ΔΔ*) OF Types.Ptr;    (* Array of permanent scaler blocks *)
  366.         ScalerFunction*:            ScalerFunctionUPP;                        (* Callback for scaler-specific tracing, debugging, etc. *)
  367.     END;
  368.  
  369.  
  370. CONST
  371.     uppGetFontTableProcInfo* = $0000FFF1; (* PROCEDURE (4 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 4 byte result; *)
  372.     uppReleaseFontTableProcInfo* = $000003C1; (* PROCEDURE (4 byte param, 4 byte param); *)
  373.     uppNewBlockProcInfo* = $00003FF1; (* PROCEDURE (4 byte param, 4 byte param, 4 byte param, 4 byte param): 4 byte result; *)
  374.     uppDisposeBlockProcInfo* = $00000FC1; (* PROCEDURE (4 byte param, 4 byte param, 4 byte param); *)
  375.     uppStreamFunctionProcInfo* = $00000FF1; (* PROCEDURE (4 byte param, 4 byte param, 4 byte param): 4 byte result; *)
  376.     uppScanLineFunctionProcInfo* = $000003C1; (* PROCEDURE (4 byte param, 4 byte param); *)
  377.     uppPostErrorFunctionProcInfo* = $000003C1; (* PROCEDURE (4 byte param, 4 byte param); *)
  378.     uppScalerFunctionProcInfo* = $000003C1; (* PROCEDURE (4 byte param, 4 byte param); *)
  379.  
  380. PROCEDURE NewGetFontTableProc*(userRoutine: GetFontTableProcPtr): GetFontTableUPP;
  381.     (*$IF NOT GENERATINGCFM *)
  382.     INLINE PASCAL $2E9F;
  383.     (*$END*)
  384.  
  385. PROCEDURE NewReleaseFontTableProc*(userRoutine: ReleaseFontTableProcPtr): ReleaseFontTableUPP;
  386.     (*$IF NOT GENERATINGCFM *)
  387.     INLINE PASCAL $2E9F;
  388.     (*$END*)
  389.  
  390. PROCEDURE NewNewBlockProc*(userRoutine: NewBlockProcPtr): NewBlockUPP;
  391.     (*$IF NOT GENERATINGCFM *)
  392.     INLINE PASCAL $2E9F;
  393.     (*$END*)
  394.  
  395. PROCEDURE NewDisposeBlockProc*(userRoutine: DisposeBlockProcPtr): DisposeBlockUPP;
  396.     (*$IF NOT GENERATINGCFM *)
  397.     INLINE PASCAL $2E9F;
  398.     (*$END*)
  399.  
  400. PROCEDURE NewStreamFunctionProc*(userRoutine: StreamFunctionProcPtr): StreamFunctionUPP;
  401.     (*$IF NOT GENERATINGCFM *)
  402.     INLINE PASCAL $2E9F;
  403.     (*$END*)
  404.  
  405. PROCEDURE NewScanLineFunctionProc*(userRoutine: ScanLineFunctionProcPtr): ScanLineFunctionUPP;
  406.     (*$IF NOT GENERATINGCFM *)
  407.     INLINE PASCAL $2E9F;
  408.     (*$END*)
  409.  
  410. PROCEDURE NewPostErrorFunctionProc*(userRoutine: PostErrorFunctionProcPtr): PostErrorFunctionUPP;
  411.     (*$IF NOT GENERATINGCFM *)
  412.     INLINE PASCAL $2E9F;
  413.     (*$END*)
  414.  
  415. PROCEDURE NewScalerFunctionProc*(userRoutine: ScalerFunctionProcPtr): ScalerFunctionUPP;
  416.     (*$IF NOT GENERATINGCFM *)
  417.     INLINE PASCAL $2E9F;
  418.     (*$END*)
  419.  
  420. PROCEDURE CallGetFontTableProc*(VAR context: scalerContext; tableTag: GXTypes.gxFontTableTag; offset: LONGINT; length: LONGINT; data: (*ΔΔUNIVΔΔ*) Types.Ptr; userRoutine: GetFontTableUPP): LONGINT;
  421.     (*$IF NOT GENERATINGCFM*)
  422.     INLINE PASCAL $205F, $4E90;
  423.     (*$END*)
  424.  
  425. PROCEDURE CallReleaseFontTableProc*(VAR context: scalerContext; fontData: (*ΔΔUNIVΔΔ*) Types.Ptr; userRoutine: ReleaseFontTableUPP);
  426.     (*$IF NOT GENERATINGCFM*)
  427.     INLINE PASCAL $205F, $4E90;
  428.     (*$END*)
  429.  
  430. PROCEDURE CallNewBlockProc*(VAR context: scalerContext; size: LONGINT; theType: scalerBlockType; oldBlock: (*ΔΔUNIVΔΔ*) Types.Ptr; userRoutine: NewBlockUPP);
  431.     (*$IF NOT GENERATINGCFM*)
  432.     INLINE PASCAL $205F, $4E90;
  433.     (*$END*)
  434.  
  435. PROCEDURE CallDisposeBlockProc*(VAR context: scalerContext; scratchData: (*ΔΔUNIVΔΔ*) Types.Ptr; theType: scalerBlockType; userRoutine: DisposeBlockUPP);
  436.     (*$IF NOT GENERATINGCFM*)
  437.     INLINE PASCAL $205F, $4E90;
  438.     (*$END*)
  439.  
  440. PROCEDURE CallStreamFunctionProc*(VAR context: scalerContext; VAR streamInfo: scalerStream; (*CONST*)VAR dataInfo: scalerStreamData; userRoutine: StreamFunctionUPP): LONGINT;
  441.     (*$IF NOT GENERATINGCFM*)
  442.     INLINE PASCAL $205F, $4E90;
  443.     (*$END*)
  444.  
  445. PROCEDURE CallScanLineFunctionProc*(VAR context: scalerContext; (*CONST*)VAR scanLine: scalerBitmap; userRoutine: ScanLineFunctionUPP);
  446.     (*$IF NOT GENERATINGCFM*)
  447.     INLINE PASCAL $205F, $4E90;
  448.     (*$END*)
  449.  
  450. PROCEDURE CallPostErrorFunctionProc*(VAR context: scalerContext; theProblem: scalerError; userRoutine: PostErrorFunctionUPP);
  451.     (*$IF NOT GENERATINGCFM*)
  452.     INLINE PASCAL $205F, $4E90;
  453.     (*$END*)
  454.  
  455. PROCEDURE CallScalerFunctionProc*(VAR context: scalerContext; data: (*ΔΔUNIVΔΔ*) Types.Ptr; userRoutine: ScalerFunctionUPP);
  456.     (*$IF NOT GENERATINGCFM*)
  457.     INLINE PASCAL $205F, $4E90;
  458.     (*$END*)
  459.  
  460. (* $ALIGN RESET*)
  461. (* $POP*)
  462.  
  463.  END ScalerTypes.
  464.